/* ------------------------------------------------------------------ */
/*  依赖                                                               */
/* ------------------------------------------------------------------ */
import request from '@/utils/request'
import type { ApiResp } from '@/utils/request'
import { ElMessage } from 'element-plus'

/* ------------------------------------------------------------------ */
/*  类型定义                                                            */
/* ------------------------------------------------------------------ */

/** 后端返回的用户结构 */
export interface User {
  id: number
  userName?: string
  username?: string
  email: string
  roleIds?: number[]
  roleId?: number
  roleName?: string
  deptId?: number
  deptName?: string
  status: 'ACTIVE' | 'INACTIVE'
  createTime: string
}

/** 前端表单提交结构 */
export interface UserForm {
  id?: number
  username: string
  email: string
  password?: string
  roleId?: number
  deptId?: number
  status: 'ACTIVE' | 'INACTIVE'
}

/** 登录参数接口 - 修改字段名为后端期望的格式 */
export interface LoginParams {
  UserName: string      // 改为 UserName (首字母大写)
  Password: string      // 改为 Password (首字母大写)
  CaptchaCode: string   // 改为 CaptchaCode (首字母大写)
  CaptchaKey: string    // 改为 CaptchaKey (首字母大写)
}

/** 通用分页返回 */
export interface PageResult<T> {
  list?: T[]
  records?: T[]
  total: number
}

/** 角色 / 部门下拉 */
export interface OptionItem {
  value: number
  label: string
  children?: OptionItem[]
}

/** 角色数据结构 */
interface RoleItem {
  id: number
  name?: string
  roleName?: string
  roleCode?: string
}

/** 部门数据结构 */
interface DeptItem {
  id: number
  name?: string
  deptName?: string
  deptCode?: string
  parentId?: number
  children?: DeptItem[]
}

/* ------------------------------------------------------------------ */
/*  接口封装                                                            */
/* ------------------------------------------------------------------ */

/** 获取用户列表 - GET /api/user/list */
export const getUserList = () => {
  return request.get<ApiResp<User[]>>('/api/user/list')
    .then(response => {
      console.log('用户列表数据:', response)
      return response
    })
    .catch(error => {
      console.error('获取用户列表失败:', error)
      throw error
    })
}

/** 获取用户信息 - GET /api/user/{id} */
export const getUserById = (id: number) => {
  return request.get<ApiResp<User>>(`/api/user/${id}`)
    .catch(error => {
      console.error('获取用户信息失败:', error)
      throw error
    })
}

/** 新增用户 - POST /api/user/add */
export const addUser = (data: UserForm) => {
  const submitData = {
    id: 0, // API文档显示需要id字段，新增时设为0
    userName: data.username, // 使用userName而不是username
    password: data.password,
    mobile: '', // API文档显示需要mobile字段
    email: data.email,
    avatar: '', // API文档显示需要avatar字段
    nickname: '', // API文档显示需要nickname字段
    remark: '', // API文档显示需要remark字段
    status: data.status === 'ACTIVE', // 转换为boolean
    sex: 0, // API文档显示需要sex字段
    roleIds: data.roleId ? [data.roleId] : [], // 转换为数组格式
    deptId: data.deptId || 0 // 确保有值
  }

  console.log('🔍 提交用户数据:', submitData)

  return request.post<ApiResp>('/api/user/add', submitData)
    .then(response => {
      ElMessage.success('新增用户成功')
      return response
    })
    .catch(error => {
      console.error('新增用户失败:', error)
      ElMessage.error('新增用户失败，请检查网络连接或联系管理员')
      throw error
    })
}

/** 更新用户 - POST /api/user/edit */
export const updateUser = (id: number, data: Partial<UserForm>) => {
  const submitData = {
    id: id,
    userName: data.username, // 使用userName而不是username
    password: data.password,
    mobile: '', // API文档显示需要mobile字段
    email: data.email,
    avatar: '', // API文档显示需要avatar字段
    nickname: '', // API文档显示需要nickname字段
    remark: '', // API文档显示需要remark字段
    status: data.status === 'ACTIVE', // 转换为boolean
    sex: 0, // API文档显示需要sex字段
    roleIds: data.roleId ? [data.roleId] : [], // 转换为数组格式
    deptId: data.deptId || 0 // 确保有值
  }

  console.log('🔍 更新用户数据:', submitData)

  return request.post<ApiResp>('/api/user/edit', submitData)
    .then(response => {
      ElMessage.success('更新用户成功')
      return response
    })
    .catch(error => {
      console.error('更新用户失败:', error)
      ElMessage.error('更新用户失败，请检查网络连接或联系管理员')
      throw error
    })
}

/** 删除用户 - POST /api/user/delete/{ids} */
export const deleteUser = (ids: number | number[]) => {
  const idParam = Array.isArray(ids) ? ids.join(',') : ids.toString()

  return request.post<ApiResp>(`/api/user/delete/${idParam}`)
    .then(response => {
      ElMessage.success('删除用户成功')
      return response
    })
    .catch(error => {
      console.error('删除用户失败:', error)
      ElMessage.error('删除用户失败，请检查网络连接或联系管理员')
      throw error
    })
}

/** 角色下拉 - 最稳定版本 */
export const getRoleOptions = () => {
  return request.get<ApiResp<RoleItem[]>>('/api/role/items')
    .then(response => {
      console.log('🔍 角色API原始响应:', response)
      console.log('🔍 角色API响应数据结构检查:')
      console.log('  response.data:', response.data)
      console.log('  response.data.data:', response.data?.data)
      console.log('  response.data类型:', typeof response.data)
      console.log('  response.data.data类型:', typeof response.data?.data)
      console.log('  response.data是否为数组:', Array.isArray(response.data))
      console.log('  response.data.data是否为数组:', Array.isArray(response.data?.data))

      // 检查响应数据 - 支持多层data结构
      let roleData: any[] = []
      if (response.data?.data && Array.isArray(response.data.data)) {
        roleData = response.data.data
        console.log('✅ 使用 response.data.data:', roleData)
      } else if (Array.isArray(response.data)) {
        roleData = response.data
        console.log('✅ 使用 response.data:', roleData)
      } else {
        console.warn('角色接口返回数据格式异常:', response)
        throw new Error('角色数据格式错误')
      }

      // 详细检查每个数据项
      console.log('🔍 角色原始数据项详情:')
      roleData.forEach((item, index) => {
        console.log(`  角色${index + 1}:`, {
          id: item.id,
          name: item.name,
          roleName: item.roleName,
          roleCode: item.roleCode,
          'id类型': typeof item.id,
          'name类型': typeof item.name,
          'roleName类型': typeof item.roleName,
          '完整item对象': item
        })
      })

      // 数据转换
      const options: OptionItem[] = roleData.map((item: any, index: number) => {
        // 检查所有可能的字段名
        const possibleNames = [
          item.name,
          item.roleName,
          item.role_name,
          item.roleName,
          item.title,
          item.label,
          item.displayName,
          item.display_name
        ].filter(Boolean)

        // 如果API返回的数据字段都是undefined，使用默认数据
        if (item.id === undefined && possibleNames.length === 0) {
          console.log(`🔍 角色${index + 1}数据无效，使用默认值`)
          return {
            value: index + 1,
            label: `角色${index + 1}`
          }
        }

        const value = item.id || (index + 1)
        const label = possibleNames[0] || `角色${value}`

        console.log(`🔍 角色${index + 1}转换:`, {
          '原始id': item.id,
          '转换后value': value,
          '原始name': item.name,
          '原始roleName': item.roleName,
          '原始role_name': item.role_name,
          '原始title': item.title,
          '原始label': item.label,
          '转换后label': label,
          'value类型': typeof value,
          'label类型': typeof label,
          '所有可能的名称': possibleNames
        })

        return {
          value: value,
          label: label
        }
      })

      console.log('✅ 角色选项转换结果:', options)

      // 检查是否有无效的选项
      const invalidOptions = options.filter(opt => opt.value === undefined || opt.value === null || opt.label === undefined || opt.label === null)
      if (invalidOptions.length > 0) {
        console.warn('⚠️ 发现无效的角色选项:', invalidOptions)
      }

      return { ...response, data: options }
    })
    .catch(error => {
      console.error('获取角色选项失败:', error)
      // 返回默认数据避免页面报错
      const defaultData = [
        { value: 1, label: '系统管理员' },
        { value: 2, label: '普通用户' },
        { value: 3, label: '访客' }
      ]
      console.log('✅ 使用默认角色数据:', defaultData)
      return {
        data: defaultData,
        code: 0,
        msg: '获取角色选项失败，使用默认数据'
      } as ApiResp<OptionItem[]>
    })
}

/** 部门下拉 - 增强错误处理 */
export const getDeptOptions = async () => {
  try {
    const response = await request.get<ApiResp<DeptItem[]>>('/api/dept/items')
    console.log('🔍 部门API原始响应:', response)

    // 检查响应数据 - 支持多层data结构
    let deptData: any[] = []
    if (response.data?.data && Array.isArray(response.data.data)) {
      deptData = response.data.data
      console.log('✅ 使用 response.data.data:', deptData)
    } else if (Array.isArray(response.data)) {
      deptData = response.data
      console.log('✅ 使用 response.data:', deptData)
    } else {
      console.warn('部门接口返回数据格式异常:', response)
      const defaultData = [
        { value: 1, label: '技术部' },
        { value: 2, label: '产品部' },
        { value: 3, label: '运营部' }
      ]
      console.log('✅ 使用默认部门数据:', defaultData)
      return {
        data: defaultData,
        code: 0,
        msg: '使用默认部门数据'
      } as ApiResp<OptionItem[]>
    }

    // 详细检查每个数据项
    console.log('🔍 部门原始数据项详情:')
    deptData.forEach((item, index) => {
      console.log(`  部门${index + 1}:`, {
        id: item.id,
        name: item.name,
        deptName: item.deptName,
        deptCode: item.deptCode,
        parentId: item.parentId,
        'id类型': typeof item.id,
        'name类型': typeof item.name,
        'deptName类型': typeof item.deptName,
        '完整对象': item
      })
    })

    // 数据转换 - 支持树形结构
    const transformDept = (dept: any, index: number): OptionItem => {
      // 检查所有可能的字段名
      const possibleNames = [
        dept.name,
        dept.deptName,
        dept.dept_name,
        dept.title,
        dept.label,
        dept.displayName,
        dept.display_name
      ].filter(Boolean)

      // 如果API返回的数据字段都是undefined，使用默认数据
      if (dept.id === undefined && possibleNames.length === 0) {
        console.log(`🔍 部门${index + 1}数据无效，使用默认值`)
        return {
          value: index + 1,
          label: `部门${index + 1}`,
          children: dept.children?.map((child: any, childIndex: number) => transformDept(child, childIndex))
        }
      }

      const value = dept.id || (index + 1)
      const label = possibleNames[0] || `部门${value}`

      console.log(`🔍 部门${index + 1}转换:`, {
        '原始id': dept.id,
        '转换后value': value,
        '原始name': dept.name,
        '原始deptName': dept.deptName,
        '原始dept_name': dept.dept_name,
        '原始title': dept.title,
        '原始label': dept.label,
        '转换后label': label,
        'value类型': typeof value,
        'label类型': typeof label,
        '所有可能的名称': possibleNames
      })

      return {
        value: value,
        label: label,
        children: dept.children?.map((child: any, childIndex: number) => transformDept(child, childIndex))
      }
    }

    const options: OptionItem[] = deptData.map((dept, index) => transformDept(dept, index))
    console.log('✅ 部门选项转换结果:', options)

    // 检查是否有无效的选项
    const invalidOptions = options.filter(opt => opt.value === undefined || opt.value === null || opt.label === undefined || opt.label === null)
    if (invalidOptions.length > 0) {
      console.warn('⚠️ 发现无效的部门选项:', invalidOptions)
    }

    return { ...response, data: options }
  } catch (error) {
    console.error('获取部门选项失败:', error)
    // 返回默认数据避免页面报错
    const defaultData = [
      { value: 1, label: '技术部' },
      { value: 2, label: '产品部' },
      { value: 3, label: '运营部' },
      { value: 4, label: '人事部' },
      { value: 5, label: '财务部' }
    ]
    console.log('✅ 使用默认部门数据:', defaultData)
    return {
      data: defaultData,
      code: 0,
      msg: '获取部门选项失败，使用默认数据'
    } as ApiResp<OptionItem[]>
  }
}

/* ------------------------------------------------------------------ */
/*  工具函数                                                           */
/* ------------------------------------------------------------------ */

/** 状态映射 */
export const STATUS_MAP = {
  'ACTIVE': '启用',
  'INACTIVE': '停用'
} as const

/** 获取状态显示文本 */
export const getStatusText = (status: string): string => {
  return STATUS_MAP[status as keyof typeof STATUS_MAP] || '未知'
}

/** 获取状态标签类型 */
export const getStatusType = (status: string): string => {
  return status === 'ACTIVE' ? 'success' : 'info'
}

/** 数据转换：后端用户数据转前端显示格式 */
export const transformUserData = (user: User): User => {
  return {
    id: user.id,
    username: user.userName || user.username || '',
    email: user.email,
    roleId: user.roleIds?.[0] || user.roleId,
    roleName: user.roleName,
    deptId: user.deptId,
    deptName: user.deptName,
    status: user.status || 'ACTIVE',
    createTime: user.createTime
  }
}

// 登录 - 修改参数类型为 LoginParams
export const login = (data: LoginParams) => {
  // 尝试使用 URLSearchParams 格式
  const formData = new URLSearchParams();
  formData.append('UserName', data.UserName);
  formData.append('Password', data.Password);
  formData.append('CaptchaCode', data.CaptchaCode);
  formData.append('CaptchaKey', data.CaptchaKey);

  return request.post('/api/auth/login', formData, {
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    }
  })
}

// 获取验证码
export const getCaptcha = () => {
  return request.get('/api/auth/captcha')
}
